#include<iostream>
#include<list>
#include<map>
#include <cstdlib>
using namespace std;

#define forn(i,n) for(int i=0;i<(n);i++)
#define forsn(i,s,n) for(int i=(s);i<(n);i++)
#define forall(it,X) for(typeof((X).begin()) it=(X).begin();it!=(X).end();it++)

int TABU_ITER;
int MAX_ITER;

long long unsigned int sum;
unsigned int instances;

/* Cantidad de iteraciones que
 * una variable queda tabu */
//#define TABU_ITER 10

/* Maxima cantidad de iteraciones que espero
 * sin encontrar un nuevo maximo */
//#define MAX_ITER 1000

void imprimir(bool* clausulas, bool* variables, int c, int v){
	/* Cantidad de clausulas satisfechas */

	int n = 0;
	forn(i,c) if(clausulas[i]) n++;
	cout << TABU_ITER << " " << MAX_ITER << " " << n << endl;

	/* Clausulas satisfechas */

/*	cout << "C";
	forn(i,c) if(clausulas[i]) cout << " " << i+1;
	cout << endl;*/

	/* Variables verdaderas */

/*	cout << "V";
	forn(i,v) if(variables[i]) cout << " " << i+1;
	cout << endl;*/
}

int clausulas_sat(map<int,list<int> > var, bool*clausulas,bool*variables, int c, int v){
	forn(i,c) clausulas[i] = false;
	forn(i,v)
		if(variables[i]==true) forall(it,var[i+1]) clausulas[*it] = true;
		else forall(it,var[-i-1]) clausulas[*it] = true;
	int cs = 0; forn(i,c) if(clausulas[i]) cs++;
	return cs;
}

int main(int argc, char** argv){

	if(argc < 3){
		cout << "tenes que pasar por lo menos 2 parametros" << endl;
		exit(1);
	}

	TABU_ITER = atoi(argv[1]);
	MAX_ITER = atoi(argv[2]);

	cerr << "tabu iter " << TABU_ITER << endl;
	cerr << "max iter " << MAX_ITER << endl;

	sum = 0;
	instances = 0;

	int c; int v;
	while( cin >> c && cin >> v && c!=-1 && v!=-1 ){

		map<int,list<int> > var;
		bool variables[v]; forn(i,v) variables[i] = true;
		bool clausulas[c]; forn(i,c) clausulas[i] = false;

		/* Leo la entrada. Guardo para cada variable,
		 * la lista de clausulas a la que pertenece.
		 * Las variables estan organizadas en un arreglo */

		forn(i,c){
			int j; cin >> j;
			forn(l,j){
				int k; cin >> k;
				var[k].push_back( i );
			}
		}
		
		/* Algoritmo */

		/* Maximos globales */
		int max_cs = -1;
		bool max_var[v];

		/* Contador de iteraciones */
		long unsigned int iteracion = 1;

		/* 'Lista' Tabu */
		long unsigned int tabu[v];
		forn(i,v) tabu[i] = 0;

		/* La ultima iteracion donde encontre un maximo.
		 * La uso para chequear el limite de arriba */
		long unsigned int last_max_iter = 0;

		while(iteracion < last_max_iter + MAX_ITER){

			/* Maximo de los vecinos y la variable
			 * que 'flipe' para producirlo */
			int local_max_cs = -1;
			int local_max_var;

			/* Por cada una de las variables */
			forn(i,v) if(iteracion>tabu[i]){

				/* Pruebo invertir el valor de la variable */
				variables[i] = !variables[i];

				/* Devuelve el numero de clausulas saturadas
				 * para un conjunto de variables */
				int cs = clausulas_sat(var, clausulas, variables, c, v);

				if(cs > local_max_cs){

					/* Si encontre un conjunto de mayor clausulas saturadas
					* para este conjunto de variables verdaderas,
					* paso a probar soluciones locales para esta nueva configuracion */

					local_max_cs = cs;
					local_max_var = i;

				}

				// Restauro el estado inicial
				variables[i] = !variables[i];

			} // Fin forn(i,v)

			/* perturbo las variables para escaparme
			 * de un posible optimo local
			 * y seguir investigando desde esta solucion */
			variables[local_max_var] = !variables[local_max_var];

			/* marco a la variable como tabu por las siguientes X iteraciones.
			 * Se supone que ya estuve revisando el espacio
			 * donde la variable tenia el valor anterior
			 * y no quiero volver a revisarlo,
			 * porque con mucha probabilidad ya encontre
			 * el optimo local de esa vecindad*/
			tabu[local_max_var] = iteracion + min(v-1,TABU_ITER);

			if(local_max_cs > max_cs){

				/* Actualizo el maxiion < last_max_iter + MAX_ITER){mo global
				 * y las variables asociadas */

				max_cs = local_max_cs;
				forn(i,v) max_var[i] = variables[i];
				last_max_iter = iteracion;
	
			}

			iteracion++;

		} // Fin while(stop)

		/* esto no esta bien. pero imprimir usa 'clausulas'
		 * y esta funcion lo modifica */
		clausulas_sat(var, clausulas, max_var, c, v);

//		cerr << "ins: " << instances << endl;
		instances++;
		forn(i,c) if(clausulas[i]) sum++;

		/* Imprimo el resultado final
		 * en el formato requerido */
//		imprimir(clausulas,max_var,c,v);

	}
	cout << TABU_ITER << " " << MAX_ITER << " " << (float)sum/instances << endl;
	return 0;
}
